package com.douma._2022_7_7;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
import java.util.Stack;

/**
 * 抖码算法，让算法学习变的简单有趣
 *
 * @作者 : 老汤
 */
public class 仿LISP运算 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //(sub (mul 2 4) (div 9 3))
        // add / sub / mul / div
        String s = sc.nextLine();

        Stack<Character> signs = new Stack<>();
        Stack<Integer> nums = new Stack<>();

        int i = 0;
        int num = 0;
        int preSign = 1;
        boolean isPreNum = false;
        while (i < s.length()) {
            char currChar = s.charAt(i);
            if (currChar == '(') {
                // 遇到了 '(' 的话，那么接下来是 3 个字符的运算符和一个空字符
                // 将对应的运算法入符号栈
                if (s.charAt(i + 1) == 'a') {
                    signs.push('+');
                } else if (s.charAt(i + 1) == 's') {
                    signs.push('-');
                } else if (s.charAt(i + 1) == 'm') {
                    signs.push('*');
                } else if (s.charAt(i + 1) == 'd') {
                    signs.push('/');
                }
                i += 5;
            } else if (currChar <= '9' && currChar >= '0') {
                // 遇到了数字字符，累加到当前数字 num 中
                num = num * 10 + (currChar - '0');
                i++;
                isPreNum = true;
            } else if (currChar == '-') {
                // 遇到了负号，先记住
                preSign = -1;
                i++;
            } else if (currChar == ' ') {
                // 遇到了空格
                if (isPreNum) {
                    // 如果空格之前是数字的话，那么先将数字乘以符号，入数字栈
                    nums.push(preSign * num);
                    // 清空数字相关的状态
                    num = 0;
                    preSign = 1;
                    isPreNum = false;
                }
                i++;
            } else if (currChar == ')') {
                // 遇到了 ')'
                if (isPreNum) {
                    // 如果空格之前是数字的话，那么先将数字乘以符号，入数字栈
                    nums.push(preSign * num);
                    // 清空数字相关的状态
                    num = 0;
                    preSign = 1;
                    isPreNum = false;
                }

                // 拿到数字栈的栈顶两个数字
                int b = nums.pop();
                int a = nums.pop();
                // 拿到符号栈栈顶的运算符
                char sign = signs.pop();
                // 如果整除 0 的话，则报错
                if (sign == '/' && b == 0) {
                    System.out.println("error");
                    sc.close();
                    return;
                }
                // 将计算的结果先放入数字栈中
                nums.push(cal(a, b, sign));
                i++;
            }
        }

        // 输出最终结果
        System.out.println(nums.pop());

        sc.close();

    }

    public static int cal(int a, int b, char sign) {
        switch (sign) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                return Math.floorDiv(a, b);  //向下取整
        }
        return 0;
    }
}
